home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / muds / lpmud312.tar / lpmud312 / main.c < prev    next >
C/C++ Source or Header  |  1992-01-11  |  9KB  |  394 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <math.h>
  4. #include <setjmp.h>
  5. #if defined(sun)
  6. #include <alloca.h>
  7. #endif
  8. #include "lint.h"
  9. #include "interpret.h"
  10. #include "object.h"
  11. #include "config.h"
  12. #include "lex.h"
  13.  
  14. extern char *prog;
  15.  
  16. extern int current_line;
  17.  
  18. int d_flag = 0;    /* Run with debug */
  19. int t_flag = 0;    /* Disable heart beat and reset */
  20. int e_flag = 0;    /* Load empty, without castles. */
  21. int comp_flag = 0; /* Trace compilations */
  22. long time_to_swap = TIME_TO_SWAP; /* marion - invocation parameter */
  23.  
  24. #ifdef YYDEBUG
  25. extern int yydebug;
  26. #endif
  27.  
  28. int port_number = PORTNO;
  29. char *reserved_area;    /* reserved for malloc() */
  30. struct svalue const0, const1;
  31.  
  32. double consts[5];
  33.  
  34. extern jmp_buf error_recovery_context;
  35. extern int error_recovery_context_exists;
  36.  
  37. extern struct object *master_ob;
  38.  
  39. struct wiz_list *back_bone_uid;
  40.  
  41. static void start_ip_demon();
  42.  
  43. int main(argc, argv)
  44.     int argc;
  45.     char **argv;
  46. {
  47.     extern int game_is_being_shut_down;
  48.     extern int current_time;
  49.     int i, new_mudlib = 0;
  50.     int no_ip_demon = 0;
  51.     char *p;
  52. #ifndef COMPAT_MODE
  53.     struct svalue *ret;
  54. #endif
  55. #ifdef MALLOC_gc
  56.     extern void gc_init();
  57. #endif
  58.  
  59. #ifdef MALLOC_gc
  60.     gc_init();
  61. #endif
  62.     const0.type = T_NUMBER; const0.u.number = 0;
  63.     const1.type = T_NUMBER; const1.u.number = 1;
  64.     /*
  65.      * Check that the definition of EXTRACT_UCHAR() is correct.
  66.      */
  67.     p = (char *)&i;
  68.     *p = -10;
  69.     if (EXTRACT_UCHAR(p) != 0x100 - 10) {
  70.     fprintf(stderr, "Bad definition of EXTRACT_UCHAR() in config.h.\n");
  71.     exit(1);
  72.     }
  73. #ifdef DRAND48
  74.     srand48(get_current_time());
  75. #else
  76. #ifdef RANDOM
  77.     srandom(get_current_time());
  78. #else
  79.     fprintf(stderr, "No random generator specified!\n");
  80. #endif /* RANDOM */
  81. #endif /* DRAND48 */
  82.     current_time = get_current_time();;
  83.     if (RESERVED_SIZE > 0)
  84.     reserved_area = malloc(RESERVED_SIZE);
  85.     for (i=0; i < sizeof consts / sizeof consts[0]; i++)
  86.     consts[i] = exp(- i / 900.0);
  87.     init_num_args();
  88.     reset_machine(1);
  89.  
  90.     /*
  91.      * The flags are parsed twice !
  92.      * The first time, we only search for the -m flag, which specifies
  93.      * another mudlib, and the D-flags, so that they will be available
  94.      * when compiling master.c.
  95.      */
  96.     for (i=1; i < argc; i++) {
  97.     if (argv[i][0] != '-')
  98.         continue;
  99.     switch(argv[i][1]) {
  100.     case 'D':
  101.         if (argv[i][2]) { /* Amylaar : allow flags to be passed down to
  102.                  the LPC preprocessor */
  103.         struct lpc_predef_s *tmp;
  104.         
  105.         tmp = (struct lpc_predef_s *)
  106.             alloca(sizeof(struct lpc_predef_s));
  107.         if (!tmp) fatal("alloca failed");
  108.         tmp->flag = argv[i]+2;
  109.         tmp->next = lpc_predefs;
  110.         lpc_predefs = tmp;
  111.         continue;
  112.         }
  113.         fprintf(stderr, "Illegal flag syntax: %s\n", argv[i]);
  114.         exit(1);
  115.     case 'o':
  116.         fprintf(stderr, "-o is an obsolete flag. Use COMPAT_MODE in config.h.\n");
  117.         exit(0);
  118.         break;
  119.     case 'N':
  120.         no_ip_demon++; continue;
  121.     case 'm':
  122.         if (chdir(argv[i]+2) == -1) {
  123.             fprintf(stderr, "Bad mudlib directory: %s\n", argv[i]+2);
  124.         exit(1);
  125.         }
  126.         new_mudlib = 1;
  127.         break;
  128.     }
  129.     }
  130.     if (!new_mudlib && chdir(MUD_LIB) == -1) {
  131.         fprintf(stderr, "Bad mudlib directory: %s\n", MUD_LIB);
  132.     exit(1);
  133.     }
  134.  
  135. #ifndef NO_IP_DEMON
  136.     if (!no_ip_demon)
  137.     start_ip_demon();
  138. #endif
  139.  
  140.     if (setjmp(error_recovery_context)) {
  141.     clear_state();
  142.     add_message("Anomaly in the fabric of world space.\n");
  143.     } else {
  144.     error_recovery_context_exists = 1;
  145.  
  146. #ifdef COMPAT_MODE
  147.         master_ob = load_object("obj/master",0);
  148. #else
  149.         master_ob = load_object("secure/master",0);
  150. #endif    
  151.     }
  152.     error_recovery_context_exists = 0;
  153.     if (master_ob == 0) {
  154.     fprintf(stderr, "The file secure/master must be loadable.\n");
  155.     exit(1);
  156.     }
  157.     /*
  158.      * Make sure master_ob is never made a dangling pointer.
  159.      * Look at apply_master_ob() for more details.
  160.      */
  161.     add_ref(master_ob, "main");
  162. #ifndef COMPAT_MODE
  163.     ret = apply_master_ob("get_root_uid", 0);
  164.     if (ret == 0 || ret->type != T_STRING) {
  165.     fprintf(stderr, "get_root_uid() in secure/master.c does not work\n");
  166.     exit(1);
  167.     }
  168.     master_ob->user = add_name(ret->u.string);
  169.     master_ob->eff_user = master_ob->user;
  170.     ret = apply_master_ob("get_bb_uid", 0);
  171.     if (ret == 0 || ret->type != T_STRING) {
  172.     fprintf(stderr, "get_bb_uid() in secure/master.c does not work\n");
  173.     exit(1);
  174.     }
  175.     back_bone_uid = add_name(ret->u.string);
  176. #endif
  177.     for (i=1; i < argc; i++) {
  178.     if (atoi(argv[i]))
  179.         port_number = atoi(argv[i]);
  180.     else if (argv[i][0] != '-') {
  181.         fprintf(stderr, "Bad argument %s\n", argv[i]);
  182.         exit(1);
  183.     } else {
  184.         /*
  185.          * Look at flags. -m and -o has already been tested.
  186.          */
  187.         switch(argv[i][1]) {
  188.         case 'f':
  189.         push_constant_string(argv[i]+2);
  190.         (void)apply_master_ob("flag", 1);
  191.         if (game_is_being_shut_down) {
  192.             fprintf(stderr, "Shutdown by master object.\n");
  193.             exit(0);
  194.         }
  195.         continue;
  196.         case 'e':
  197.         e_flag++; continue;
  198.         case 'D':
  199.         continue;
  200.         case 'N':
  201.         continue;
  202.         case 'm':
  203.         continue;
  204.         case 'd':
  205.         d_flag++; continue;
  206.         case 'c':
  207.         comp_flag++; continue;
  208.         case 't':
  209.         t_flag++; continue;
  210. #if TIME_TO_SWAP > 0
  211.         case 's':
  212.         time_to_swap = atoi (&argv[i][2]);
  213.         continue;
  214. #endif
  215. #ifdef YYDEBUG
  216.         case 'y':
  217.         yydebug = 1; continue;
  218. #endif
  219.         default:
  220.         fprintf(stderr, "Unknown flag: %s\n", argv[i]);
  221.         exit(1);
  222.         }
  223.     }
  224.     }
  225.     get_simul_efun(apply_master_ob("get_simul_efun", 0));
  226.     if (game_is_being_shut_down)
  227.     exit(1);
  228.     load_wiz_file();
  229.     set_inc_list(apply_master_ob("define_include_dirs", 0));
  230. #ifdef COMPAT_MODE
  231.     load_first_objects();
  232.     (void)apply_master_ob("epilog", 0);
  233. #else
  234.     preload_objects(e_flag);
  235. #endif
  236.     backend();
  237.     return 0;
  238. }
  239.  
  240. char *string_copy(str)
  241.     char *str;
  242. {
  243.     char *p;
  244.  
  245.     p = xalloc(strlen(str)+1);
  246.     (void)strcpy(p, str);
  247.     return p;
  248. }
  249.  
  250. /*VARARGS1*/
  251. void debug_message(a, b, c, d, e, f, g, h, i, j)
  252.     char *a;
  253.     int b, c, d, e, f, g, h, i, j;
  254. {
  255.     static FILE *fp = NULL;
  256.     char deb[100];
  257.     char name[100];
  258.  
  259.     if (fp == NULL) {
  260. #ifndef MSDOS
  261.     gethostname(name,sizeof name);
  262.     sprintf(deb,"%s.debug.log",name);
  263. #else
  264.     strcpy(deb,"debug.log");
  265. #endif
  266.     fp = fopen(deb, "w");
  267.     if (fp == NULL) {
  268.         perror(deb);
  269.         abort();
  270.     }
  271.     }
  272.     (void)fprintf(fp, a, b, c, d, e, f, g, h, i, j);
  273.     (void)fflush(fp);
  274. }
  275.  
  276. void debug_message_svalue(v)
  277.     struct svalue *v;
  278. {
  279.     if (v == 0) {
  280.     debug_message("<NULL>");
  281.     return;
  282.     }
  283.     switch(v->type) {
  284.     case T_NUMBER:
  285.     debug_message("%d", v->u.number);
  286.     return;
  287.     case T_STRING:
  288.     debug_message("\"%s\"", v->u.string);
  289.     return;
  290.     case T_OBJECT:
  291.     debug_message("OBJ(%s)", v->u.ob->name);
  292.     return;
  293.     case T_LVALUE:
  294.     debug_message("Pointer to ");
  295.     debug_message_svalue(v->u.lvalue);
  296.     return;
  297.     default:
  298.     debug_message("<INVALID>\n");
  299.     return;
  300.     }
  301. }
  302.  
  303. #ifdef malloc
  304. #undef malloc
  305. #endif
  306.  
  307. int slow_shut_down_to_do = 0;
  308.  
  309. char *xalloc(size)
  310.     int size;
  311. {
  312.     char *p;
  313.     static int going_to_exit;
  314.  
  315.     if (going_to_exit)
  316.     exit(3);
  317.     if (size == 0)
  318.     fatal("Tried to allocate 0 bytes.\n");
  319.     p = malloc(size);
  320.     if (p == 0) {
  321.     if (reserved_area) {
  322.         free(reserved_area);
  323.         p = "Temporary out of MEMORY. Freeing reserve.\n";
  324.         write(1, p, strlen(p));
  325.         reserved_area = 0;
  326.         slow_shut_down_to_do = 6;
  327.         return xalloc(size);    /* Try again */
  328.     }
  329.     going_to_exit = 1;
  330.     p = "Totally out of MEMORY.\n";
  331.     write(1, p, strlen(p));
  332.     (void)dump_trace(0);
  333.     exit(2);
  334.     }
  335.     return p;
  336. }
  337.  
  338. #ifndef NO_IP_DEMON
  339. static void start_ip_demon()
  340. {
  341.     extern FILE *f_ip_demon, *f_ip_demon_wr;
  342.     char path[100];
  343.     int tochild[2], fromchild[2];
  344.     int pid;
  345.     char c;
  346.  
  347.     if(pipe(tochild) < 0)
  348.         return;
  349.     if(pipe(fromchild) < 0) {
  350.         close(tochild[0]);
  351.         close(tochild[1]);
  352.         return;
  353.     }
  354.     if((pid = fork()) == 0) {
  355.         /* Child */
  356.         dup2(tochild[0], 0);
  357.         dup2(fromchild[1], 1);
  358.         close(tochild[0]);
  359.         close(tochild[1]);
  360.         close(fromchild[0]);
  361.         close(fromchild[1]);
  362.     if (strlen(BINDIR) + 7 <= sizeof path) {
  363.         sprintf(path, "%s/hname", BINDIR);
  364.         execl((char *)path, "hname", 0);
  365.     }
  366.     write(1, "0", 1);    /* indicate failure */
  367.         fprintf(stderr, "exec of hname failed.\n");
  368.         _exit(1);
  369.     }
  370.     if(pid == -1) {
  371.         close(tochild[0]);
  372.         close(tochild[1]);
  373.         close(fromchild[0]);
  374.         close(fromchild[1]);
  375.         return;
  376.     }
  377.     close(tochild[0]);
  378.     close(fromchild[1]);
  379.     read(fromchild[0], &c, 1);
  380.     if (c == '0') {
  381.         close(tochild[1]);
  382.         close(fromchild[0]);
  383.     return;
  384.     }
  385.     f_ip_demon_wr = fdopen(tochild[1], "w");
  386.     f_ip_demon = fdopen(fromchild[0], "r");
  387.     if (f_ip_demon == NULL || f_ip_demon_wr == NULL) {
  388.     f_ip_demon = NULL;
  389.         close(tochild[1]);
  390.         close(fromchild[0]);
  391.     }
  392. }
  393. #endif
  394.